/*

  * Copyright 2001-2004 The Apache Software Foundation.

  *

  * Licensed under the Apache License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at

  *

  *      http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 package org.apache.geronimo.ews.jaxrpcmapping;

 /**

  * @author Ias (iasandcb@tmax.co.kr)

  *

  */

 import java.io.IOException;

 import java.lang.reflect.Constructor;

 import java.util.ArrayList;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.Iterator;

 import java.util.Map;

 import java.util.Vector;

 import javax.wsdl.Binding;

 import javax.wsdl.Definition;

 import javax.wsdl.Fault;

 import javax.wsdl.Message;

 import javax.wsdl.Operation;

 import javax.wsdl.OperationType;

 import javax.wsdl.Port;

 import javax.wsdl.PortType;

 import javax.wsdl.Service;

 import javax.xml.namespace.QName;

 import javax.xml.rpc.holders.BooleanHolder;

 import org.apache.axis.utils.JavaUtils;

 import org.apache.axis.utils.Messages;

 import org.apache.axis.wsdl.gen.Generator;

 import org.apache.axis.wsdl.gen.GeneratorFactory;

 import org.apache.axis.wsdl.gen.NoopGenerator;

 import org.apache.axis.wsdl.symbolTable.BaseTypeMapping;

 import org.apache.axis.wsdl.symbolTable.BindingEntry;

 import org.apache.axis.wsdl.symbolTable.ContainedAttribute;

 import org.apache.axis.wsdl.symbolTable.Element;

 import org.apache.axis.wsdl.symbolTable.ElementDecl;

 import org.apache.axis.wsdl.symbolTable.FaultInfo;

 import org.apache.axis.wsdl.symbolTable.MessageEntry;

 import org.apache.axis.wsdl.symbolTable.Parameter;

 import org.apache.axis.wsdl.symbolTable.Parameters;

 import org.apache.axis.wsdl.symbolTable.PortTypeEntry;

 import org.apache.axis.wsdl.symbolTable.SchemaUtils;

 import org.apache.axis.wsdl.symbolTable.ServiceEntry;

 import org.apache.axis.wsdl.symbolTable.SymTabEntry;

 import org.apache.axis.wsdl.symbolTable.SymbolTable;

 import org.apache.axis.wsdl.symbolTable.Type;

 import org.apache.axis.wsdl.symbolTable.TypeEntry;

 import org.apache.axis.wsdl.toJava.Emitter;

 import org.apache.axis.wsdl.toJava.JavaBindingWriter;

 import org.apache.axis.wsdl.toJava.JavaDefinitionWriter;

 import org.apache.axis.wsdl.toJava.JavaDeployWriter;

 import org.apache.axis.wsdl.toJava.JavaGeneratorFactory;

 import org.apache.axis.wsdl.toJava.JavaServiceWriter;

 import org.apache.axis.wsdl.toJava.JavaTypeWriter;

 import org.apache.axis.wsdl.toJava.JavaUndeployWriter;

 import org.apache.axis.wsdl.toJava.Utils;

 /**

  * This is WsdlToJ2ee's implementation of the GeneratorFactory

  *

  * @author Ias (iasandcb@tmax.co.kr)

  */

     protected J2eeEmitter emitter;

     protected SymbolTable symbolTable;

     private JaxRpcMapper mapper;

     /**

      * Default constructor.  Note that this class is unusable until setEmitter

      * is called.

      */

     } // ctor

     } // ctor

     } // setEmitter

     } // addGenerators

     /**

      * These addXXXGenerators are called by the constructor.

      * If an extender of this factory wants to CHANGE the set

      * of generators that are called per WSDL construct, they

      * should override these addXXXGenerators methods.  If all

      * an extender wants to do is ADD a generator, then the

      * extension should simply call addGenerator.

      * (NOTE:  It doesn't quite work this way, yet.  Only the

      * Definition generators fit this model at this point in

      * time.)

      */

     } // addMessageGenerators

     } // addPortTypeGenerators

     } // addBindingGenerators

     } // addServiceGenerators

     } // addTypeGenerators

     } // addDefinitionGenerators

     /**

      * Do the Wsdl2java generator pass:

      * - resolve name clashes

      * - construct signatures

      */

         } else {

         }

     } // generatorPass

     /**

      * Since Wsdl2java doesn't emit anything for Messages, return the No-op generator.

      */

     private Writers messageWriters = new Writers();

     } // getGenerator

     /**

      * Return Wsdl2java's JavaPortTypeWriter object.

      */

     private Writers portTypeWriters = new Writers();

     } // getGenerator

     /**

      * Return Wsdl2java's JavaBindingWriter object.

      */

     protected Writers bindingWriters = new Writers();

     } // getGenerator

     /**

      * Return Wsdl2java's JavaServiceWriter object.

      */

     protected Writers serviceWriters = new Writers();

     } // getGenerator

     /**

      * Return Wsdl2java's JavaTypeWriter object.

      */

     protected Writers typeWriters = new Writers();

     } // getGenerator

     /**

      * Return Wsdl2java's JavaDefinitionWriter object.

      */

     private Writers defWriters = new Writers();

     } // getGenerator

     // Hack class just to play with the idea of adding writers

         Vector writers = new Vector();

         SymbolTable symbolTable = null;

         Generator baseWriter = null;

         // entry or def, but not both, will be a parameter.

         SymTabEntry entry = null;

         Definition def = null;

         } // addWriter

         } // addStuff

         } // addStuff

             }

             } else {

             }

                 } catch (Throwable t) {

                 }

             }

         } // generate

     } // class Writers

         // This is just a hack right now... it just works with Service

         }

     } // addGenerator

     /**

      * Fill in the names of each SymTabEntry with the javaified name.

      * Note: This method also ensures that anonymous types are

      * given unique java type names.

      */

                 // Use the type or the referenced type's QName to generate the java name.

                 }

                 // If it is not a type, then use this entry's QName to

                 // generate its name.

                 else {

                 }

             }

         }

     } // javifyNames

     /**

      * Refactored to call recursively for JAX-RPC 1.1 spec 4.2.5.

      */

         }

                     && SchemaUtils.getContainedAttributeTypes(te.getNode(), symbolTable) == null) {

                     // Case 1:

                     // <simpleType name="mySimpleStringType">

                     //   <restriction base="xs:string">

                     //   </restriction>

                     // </simpleType>

                 }

                     // Case 2:

                     // <simpleType name="FooString">

                     //   <restriction base="foo:mySimpleStringType">

                     //   </restriction>

                     // </simpleType>

                 }

             }

         }

         // Need to javify the ref'd TypeEntry if it was not

         // already processed

             // Get the QName of the ref'd TypeEntry, which

             // is will be used to javify the name

             // In case of <xsd:list itemType="...">,

             // set typeQName to the value of the itemType attribute.

                 // OW Guillaume Change

                 // found a list

             }

                     indexOf(SymbolTable.ANON_TOKEN) >= 0) {

                 // This is an anonymous type name.

                 // Axis uses '>' as a nesting token to generate

                 // unique qnames for anonymous types.

                 // Only consider the localName after the last '>'

                 // when generating the java name

                 // If there is already an existing type,

                 // there will be a collision.

                 // If there is an existing anon type,

                 // there will be a  collision.

                 // In both cases, mangle the name.

                             new QName(typeQName.getNamespaceURI(),

                                     localName);

                 }

             }

             // Now set the name with the constructed qname

             }

             }

                 }

             }

                 }

             }

         }

         // Set the entry with the same name as the ref'd entry

         // but add the appropriate amount of dimensions

     }

     /**

      * setFaultContext:

      * Processes the symbol table and sets the COMPLEX_TYPE_FAULT

      * on each TypeEntry that is a complexType and is referenced in

      * a fault message.  TypeEntries that are the base or derived

      * from such a TypeEntry are also marked with COMPLEX_TYPE_FAULT.

      * The containing MessageEntry is marked with cOMPLEX_TYPE_FAULT, and

      * all MessageEntries for faults are tagged with the

      * EXCEPTION_CLASS_NAME variable, which indicates the java exception

      * class name.

      *

      * @param symbolTable SymbolTable

      */

                 // Inspect each BindingEntry in the Symbol Table

                     // set the context for all faults for this binding.

                         }

                     }

                 }

             }

         }

     } // setFaultContext

     /**

      * setFaultContext:

      * Helper routine for the setFaultContext method above.

      * Examines the indicated fault and sets COMPLEX_TYPE_FAULT

      * EXCEPTION_DATA_TYPE and EXCEPTION_CLASS_NAME as appropriate.

      *

      * @param fault       FaultInfo to analyze

      * @param symbolTable SymbolTable

      */

                                  SymbolTable symbolTable) {

         // Get the parts of the fault's message.

         // An IOException is thrown if the parts cannot be

         // processed.  Skip such parts for this analysis

                     fault.getMessage().getOrderedParts(null),

                     false,

                     fault.getName(),

                     null);

         } catch (IOException e) {

         }

         // Inspect each TypeEntry referenced in a Fault Message Part

             // If the TypeEntry is an element, advance to the type.

             // This occurs if the message part uses the element= attribute

             }

             // remember the QName of the type.

             // Determine if the te should be processed using the

             // simple type mapping or the complex type mapping

             // NOTE: treat array types as simple types

                     te.isSimpleType() ||

                     (te.getDimensions().length() > 0 &&

                     te.getRefType().getBaseType() != null)) {

                 // Simple Type Exception

             } else {

                 // Complex Type Exception

                         !isComplexFault.booleanValue()) {

                     // Mark the type as a complex type fault

                             Boolean.TRUE);

                                 Boolean.TRUE);

                     }

                     // Mark all derived types as Complex Faults

                             org.apache.axis.wsdl.symbolTable.Utils.getDerivedTypes(te, symbolTable);

                                 derivedI.next();

                                 Boolean.TRUE);

                     }

                     // Mark all base types as Complex Faults

                             symbolTable);

                                 Boolean.TRUE);

                                 symbolTable);

                     }

                 }

                 // The exception class name is the name of the type

             }

         }

         // Set the name of the exception and

         // whether the exception is a complex type

                     faultXmlType);

                         Boolean.TRUE);

             } else {

                 }

             }

                     exceptionClassName);

         }

     }

                     // The SEI (Service Endpoint Interface) name

                     // is always the portType name.

                     }

                     }

                     // get ports

                                 symbolTable.getBindingEntry(binding.getQName());

                         // If this isn't a SOAP binding, skip it

                         }

                         }

                     }

                 }

             }

         }

     } // determineInterfaceNames

     /**

      * Messages, PortTypes, Bindings, and Services can share the same name.  If they do in this

      * Definition, force their names to be suffixed with _PortType and _Service, respectively.

      */

         // Keep a list of anonymous types so we don't try to resolve them twice.

             // Remove MessageEntries since they are not mapped

                 } else {

                 }

             }

                 // Common Special Case:

                 // If a Type and Element have the same QName, and the Element

                 // references the Type, then they are the same class so

                 // don't bother mangling.

                         ((v.elementAt(0) instanceof Element &&

                         v.elementAt(1) instanceof Type) ||

                         (v.elementAt(1) instanceof Element &&

                         v.elementAt(0) instanceof Type))) {

                     } else {

                     }

                             eType.equals(e.getQName()) &&

                             !forElement.value)

                 }

                 // Other Special Case:

                 // If the names are already different, no mangling is needed.

                                 entry instanceof BindingEntry) {

                             ; // Don't process these

                         }

                     }

                 }

                 // Full Mangle if resolution is necessary.

                                     "_ElemType"));

                             // If this global element was defined using

                             // an anonymous type, then need to change the

                             // java name of the anonymous type to match.

                                     SymbolTable.ANON_TOKEN +

                                     entry.getQName().getLocalPart());

                             }

                             // Search all other types for java names that match this one.

                             // The sameJavaClass method returns true if the java names are

                             // the same (ignores [] ).

                                             types.next();

                                             sameJavaClass(entry.getName(), type.getName())) {

                                     }

                                 }

                             }

                             // If this is an anonymous type, it's name was resolved in

                             // the previous if block.  Don't reresolve it.

                             }

                                     "_Service"));

                         }

                         // else if (entry instanceof MessageEntry) {

                         //     we don't care about messages

                         // }

                             // If there is no literal use, then we never see a

                             // class named directly from the binding name.  They

                             // all have suffixes:  Stub, Skeleton, Impl.

                             // If there IS literal use, then the SDI will be

                             // named after the binding name, so there is the

                             // possibility of a name clash.

                                         "_Binding"));

                             }

                         }

                     }

                 }

             }

         }

     } // resolveNameClashes

     /**

      * Change the indicated type name into a mangled form using the mangle string.

      */

         } else

     }

     /**

      * Returns true if same java class, ignore []

      */

     }

     /**

      * The --all flag is set on the command line (or generateAll(true) is called

      * on WSDL2Java). Set all symbols as referenced (except nonSOAP bindings

      * which we don't know how to deal with).

      */

                         ((BindingEntry) entry).getBindingType() !=

                         BindingEntry.TYPE_SOAP) {

                 } else {

                 }

             }

         }

     } // setAllReferencesToTrue

     /**

      * If a binding's type is not TYPE_SOAP, then we don't use that binding

      * or that binding's portType.

      */

         // Look at all uses of the portTypes.  If none of the portType's bindings are of type

         // TYPE_SOAP, then turn off that portType's isReferenced flag.

                             symbolTable.getPortTypeEntry(portType.getQName());

                         // If a binding is of type TYPE_SOAP, then mark its portType used

                         // (ie., add it to the usedPortTypes list.  If the portType was

                         // previously marked as unused, unmark it (in other words, remove it

                         // from the unusedPortTypes list).

                         }

                     } else {

                         // If a binding is not of type TYPE_SOAP, then mark its portType as

                         // unused ONLY if it hasn't already been marked as used.

                         }

                     }

                 }

             }

         }

         // Go through all the portTypes that are marked as unused and set their isReferenced flags

         // to false.

         }

     } // ignoreNonSOAPBindings

                             symbolTable.getPortTypeEntry(binding.getPortType().getQName());

                         }

                         // OW Change Jerome

                         // operation name must be set otherwise problem during matching beetween WSDD operation and java method

                         // end

                         } else { // ONE_WAY or REQUEST_RESPONSE

                                 // OW Change Guillaume

                                 // parameters.returnParam may be null (no return value for the given operation)

                                 }

                                             mapper.getJavaMethodParamType(bEntry, operation, j);

                                     }

                                 }

                             }

                         }

                     }

                 }

             }

         }

     } // constructSignatures

     /**

      * Construct the signature, which is used by both the interface and the stub.

      */

         }

             } else {

             }

             } else {

                         + javifiedName;

             }

         }

             // Collect the list of faults into a single string, separated by commas.

                         Utils.getFullExceptionName(fault.getMessage(), symbolTable);

                 }

             }

         }

     } // constructSignature

     /**

      * Find all inout/out parameters and add a flag to the Type of that parameter saying a holder

      * is needed.

      */

                     // If entry is a BindingEntry, look at all the Parameters

                     // in its portType

 //                      PortTypeEntry ptEntry =

 //                              symbolTable.getPortTypeEntry(bEntry.getBinding().getPortType().getQName());

                             bEntry.getParameters().values().iterator();

                                     (Parameter) parms.list.get(j);

                             // If the given parameter is an inout or out parameter, then

                             // set a HOLDER_IS_NEEDED flag using the dynamicVar design.

                                         Boolean.TRUE);

                                 //If this is a complex then set the HOLDER_IS_NEEDED

                                 //for the reftype too.

                                             Boolean.TRUE);

                                 }

                                 // If the type is a DefinedElement, need to

                                 // set HOLDER_IS_NEEDED on the anonymous type.

                                         getElementAnonQName(p.getType().getNode());

                                             symbolTable.getType(anonQName);

                                                 Boolean.TRUE);

                                     }

                                 }

                             }

                         }

                     }

                 }

             }

         }

     } // determineIfHoldersNeeded

     /**

      * Get TypeMapping to use for translating

      * QNames to java base types

      */

     BaseTypeMapping btm = null;

     }

                 //TypeMapping defaultTM = DefaultTypeMappingImpl.getSingleton();

                             .getLocalPart());

                     else

                 }

             };

         }

     }

 //    private Class getDeployerWriterClass(){

 //        try{

 //            if(emitter.isUsedbyws4j2ee()){

 //                return Class.forName("org.apache.geronimo.ews.ws4j2ee.toWs.ws.J2eeDeployWriter");

 //            }else

 //                return  JavaDeployWriter.class;

 //        } catch (Exception e) {

 //            e.printStackTrace();

 //            throw new RuntimeException(e);

 //        }

 //    }

 }